home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / managers / dragClasses / DragProxy.as
Text File  |  2009-12-16  |  16KB  |  471 lines
  1. package mx.managers.dragClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.InteractiveObject;
  6.    import flash.events.Event;
  7.    import flash.events.IEventDispatcher;
  8.    import flash.events.KeyboardEvent;
  9.    import flash.events.MouseEvent;
  10.    import flash.geom.Point;
  11.    import mx.core.DragSource;
  12.    import mx.core.IUIComponent;
  13.    import mx.core.UIComponent;
  14.    import mx.core.mx_internal;
  15.    import mx.effects.Move;
  16.    import mx.effects.Zoom;
  17.    import mx.events.DragEvent;
  18.    import mx.events.EffectEvent;
  19.    import mx.events.InterDragManagerEvent;
  20.    import mx.events.InterManagerRequest;
  21.    import mx.events.SandboxMouseEvent;
  22.    import mx.managers.CursorManager;
  23.    import mx.managers.DragManager;
  24.    import mx.managers.ISystemManager;
  25.    import mx.managers.SystemManager;
  26.    import mx.styles.CSSStyleDeclaration;
  27.    import mx.styles.StyleManager;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class DragProxy extends UIComponent
  32.    {
  33.       
  34.       mx_internal static const VERSION:String = "3.5.0.12683";
  35.        
  36.       
  37.       public var allowMove:Boolean = true;
  38.       
  39.       private var cursorClass:Class = null;
  40.       
  41.       public var action:String;
  42.       
  43.       private var sandboxRoot:IEventDispatcher;
  44.       
  45.       public var target:DisplayObject = null;
  46.       
  47.       public var dragInitiator:IUIComponent;
  48.       
  49.       public var xOffset:Number;
  50.       
  51.       public var yOffset:Number;
  52.       
  53.       public var dragSource:DragSource;
  54.       
  55.       private var cursorID:int = 0;
  56.       
  57.       private var lastMouseEvent:MouseEvent;
  58.       
  59.       public var startX:Number;
  60.       
  61.       public var startY:Number;
  62.       
  63.       private var lastKeyEvent:KeyboardEvent;
  64.       
  65.       public function DragProxy(param1:IUIComponent, param2:DragSource)
  66.       {
  67.          super();
  68.          this.dragInitiator = param1;
  69.          this.dragSource = param2;
  70.          var _loc3_:ISystemManager = param1.systemManager.topLevelSystemManager as ISystemManager;
  71.          var _loc4_:IEventDispatcher;
  72.          (_loc4_ = sandboxRoot = _loc3_.getSandboxRoot()).addEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  73.          _loc4_.addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  74.          _loc4_.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  75.          _loc4_.addEventListener(KeyboardEvent.KEY_UP,keyUpHandler);
  76.       }
  77.       
  78.       private static function getObjectsUnderPoint(param1:DisplayObject, param2:Point, param3:Array) : void
  79.       {
  80.          var doc:DisplayObjectContainer = null;
  81.          var rc:Object = null;
  82.          var n:int = 0;
  83.          var i:int = 0;
  84.          var child:DisplayObject = null;
  85.          var obj:DisplayObject = param1;
  86.          var pt:Point = param2;
  87.          var arr:Array = param3;
  88.          if(!obj.visible)
  89.          {
  90.             return;
  91.          }
  92.          if(obj is UIComponent && !UIComponent(obj).$visible)
  93.          {
  94.             return;
  95.          }
  96.          if(obj.hitTestPoint(pt.x,pt.y,true))
  97.          {
  98.             if(obj is InteractiveObject && InteractiveObject(obj).mouseEnabled)
  99.             {
  100.                arr.push(obj);
  101.             }
  102.             if(obj is DisplayObjectContainer)
  103.             {
  104.                doc = obj as DisplayObjectContainer;
  105.                if(doc.mouseChildren)
  106.                {
  107.                   if("rawChildren" in doc)
  108.                   {
  109.                      rc = doc["rawChildren"];
  110.                      n = rc.numChildren;
  111.                      i = 0;
  112.                      while(i < n)
  113.                      {
  114.                         try
  115.                         {
  116.                            getObjectsUnderPoint(rc.getChildAt(i),pt,arr);
  117.                         }
  118.                         catch(e:Error)
  119.                         {
  120.                         }
  121.                         i++;
  122.                      }
  123.                   }
  124.                   else if(doc.numChildren)
  125.                   {
  126.                      n = doc.numChildren;
  127.                      i = 0;
  128.                      while(i < n)
  129.                      {
  130.                         try
  131.                         {
  132.                            child = doc.getChildAt(i);
  133.                            getObjectsUnderPoint(child,pt,arr);
  134.                         }
  135.                         catch(e:Error)
  136.                         {
  137.                         }
  138.                         i++;
  139.                      }
  140.                   }
  141.                }
  142.             }
  143.          }
  144.       }
  145.       
  146.       public function mouseUpHandler(param1:MouseEvent) : void
  147.       {
  148.          var _loc2_:DragEvent = null;
  149.          var _loc6_:Point = null;
  150.          var _loc7_:Move = null;
  151.          var _loc8_:Zoom = null;
  152.          var _loc9_:Move = null;
  153.          var _loc3_:ISystemManager = dragInitiator.systemManager.topLevelSystemManager as ISystemManager;
  154.          var _loc4_:IEventDispatcher;
  155.          (_loc4_ = sandboxRoot).removeEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  156.          _loc4_.removeEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  157.          _loc4_.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  158.          _loc4_.removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,mouseLeaveHandler);
  159.          _loc4_.removeEventListener(KeyboardEvent.KEY_UP,keyUpHandler);
  160.          var _loc5_:Object = automationDelegate;
  161.          if(target && action != DragManager.NONE)
  162.          {
  163.             _loc2_ = new DragEvent(DragEvent.DRAG_DROP);
  164.             _loc2_.dragInitiator = dragInitiator;
  165.             _loc2_.dragSource = dragSource;
  166.             _loc2_.action = action;
  167.             _loc2_.ctrlKey = param1.ctrlKey;
  168.             _loc2_.altKey = param1.altKey;
  169.             _loc2_.shiftKey = param1.shiftKey;
  170.             (_loc6_ = new Point()).x = lastMouseEvent.localX;
  171.             _loc6_.y = lastMouseEvent.localY;
  172.             _loc6_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc6_);
  173.             _loc6_ = DisplayObject(target).globalToLocal(_loc6_);
  174.             _loc2_.localX = _loc6_.x;
  175.             _loc2_.localY = _loc6_.y;
  176.             if(_loc5_)
  177.             {
  178.                _loc5_.recordAutomatableDragDrop(target,_loc2_);
  179.             }
  180.             _dispatchDragEvent(target,_loc2_);
  181.          }
  182.          else
  183.          {
  184.             action = DragManager.NONE;
  185.          }
  186.          if(action == DragManager.NONE)
  187.          {
  188.             (_loc7_ = new Move(this)).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  189.             _loc7_.xFrom = x;
  190.             _loc7_.yFrom = y;
  191.             _loc7_.xTo = startX;
  192.             _loc7_.yTo = startY;
  193.             _loc7_.duration = 200;
  194.             _loc7_.play();
  195.          }
  196.          else
  197.          {
  198.             _loc8_ = new Zoom(this);
  199.             _loc8_.zoomWidthFrom = _loc8_.zoomHeightFrom = 1;
  200.             _loc8_.zoomWidthTo = _loc8_.zoomHeightTo = 0;
  201.             _loc8_.duration = 200;
  202.             _loc8_.play();
  203.             (_loc9_ = new Move(this)).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  204.             _loc9_.xFrom = x;
  205.             _loc9_.yFrom = this.y;
  206.             _loc9_.xTo = parent.mouseX;
  207.             _loc9_.yTo = parent.mouseY;
  208.             _loc9_.duration = 200;
  209.             _loc9_.play();
  210.          }
  211.          _loc2_ = new DragEvent(DragEvent.DRAG_COMPLETE);
  212.          _loc2_.dragInitiator = dragInitiator;
  213.          _loc2_.dragSource = dragSource;
  214.          _loc2_.relatedObject = InteractiveObject(target);
  215.          _loc2_.action = action;
  216.          _loc2_.ctrlKey = param1.ctrlKey;
  217.          _loc2_.altKey = param1.altKey;
  218.          _loc2_.shiftKey = param1.shiftKey;
  219.          dragInitiator.dispatchEvent(_loc2_);
  220.          if(_loc5_ && action == DragManager.NONE)
  221.          {
  222.             _loc5_.recordAutomatableDragCancel(dragInitiator,_loc2_);
  223.          }
  224.          cursorManager.removeCursor(cursorID);
  225.          cursorID = CursorManager.NO_CURSOR;
  226.          this.lastMouseEvent = null;
  227.       }
  228.       
  229.       private function isSameOrChildApplicationDomain(param1:Object) : Boolean
  230.       {
  231.          var _loc2_:DisplayObject = SystemManager.getSWFRoot(param1);
  232.          if(_loc2_)
  233.          {
  234.             return true;
  235.          }
  236.          var _loc3_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST);
  237.          _loc3_.name = "hasSWFBridges";
  238.          sandboxRoot.dispatchEvent(_loc3_);
  239.          if(!_loc3_.value)
  240.          {
  241.             return true;
  242.          }
  243.          return false;
  244.       }
  245.       
  246.       public function showFeedback() : void
  247.       {
  248.          var _loc1_:Class = cursorClass;
  249.          var _loc2_:CSSStyleDeclaration = StyleManager.getStyleDeclaration("DragManager");
  250.          if(action == DragManager.COPY)
  251.          {
  252.             _loc1_ = _loc2_.getStyle("copyCursor");
  253.          }
  254.          else if(action == DragManager.LINK)
  255.          {
  256.             _loc1_ = _loc2_.getStyle("linkCursor");
  257.          }
  258.          else if(action == DragManager.NONE)
  259.          {
  260.             _loc1_ = _loc2_.getStyle("rejectCursor");
  261.          }
  262.          else
  263.          {
  264.             _loc1_ = _loc2_.getStyle("moveCursor");
  265.          }
  266.          if(_loc1_ != cursorClass)
  267.          {
  268.             cursorClass = _loc1_;
  269.             if(cursorID != CursorManager.NO_CURSOR)
  270.             {
  271.                cursorManager.removeCursor(cursorID);
  272.             }
  273.             cursorID = cursorManager.setCursor(cursorClass,2,0,0);
  274.          }
  275.       }
  276.       
  277.       override public function initialize() : void
  278.       {
  279.          super.initialize();
  280.          dragInitiator.systemManager.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,mouseLeaveHandler);
  281.          if(!getFocus())
  282.          {
  283.             setFocus();
  284.          }
  285.       }
  286.       
  287.       public function mouseMoveHandler(param1:MouseEvent) : void
  288.       {
  289.          var _loc2_:DragEvent = null;
  290.          var _loc3_:DisplayObject = null;
  291.          var _loc4_:int = 0;
  292.          var _loc10_:Array = null;
  293.          var _loc14_:Boolean = false;
  294.          var _loc15_:DisplayObject = null;
  295.          lastMouseEvent = param1;
  296.          var _loc5_:Point = new Point();
  297.          var _loc6_:Point = new Point(param1.localX,param1.localY);
  298.          var _loc7_:Point = DisplayObject(param1.target).localToGlobal(_loc6_);
  299.          var _loc8_:Number = (_loc6_ = DisplayObject(sandboxRoot).globalToLocal(_loc7_)).x;
  300.          var _loc9_:Number = _loc6_.y;
  301.          x = _loc8_ - xOffset;
  302.          y = _loc9_ - yOffset;
  303.          if(!param1)
  304.          {
  305.             return;
  306.          }
  307.          var _loc11_:IEventDispatcher = systemManager.getTopLevelRoot();
  308.          _loc10_ = [];
  309.          DragProxy.getObjectsUnderPoint(DisplayObject(sandboxRoot),_loc7_,_loc10_);
  310.          var _loc12_:DisplayObject = null;
  311.          var _loc13_:int = _loc10_.length - 1;
  312.          while(_loc13_ >= 0)
  313.          {
  314.             if((_loc12_ = _loc10_[_loc13_]) != this && !contains(_loc12_))
  315.             {
  316.                break;
  317.             }
  318.             _loc13_--;
  319.          }
  320.          if(target)
  321.          {
  322.             _loc14_ = false;
  323.             _loc15_ = target;
  324.             _loc3_ = _loc12_;
  325.             while(_loc3_)
  326.             {
  327.                if(_loc3_ == target)
  328.                {
  329.                   dispatchDragEvent(DragEvent.DRAG_OVER,param1,_loc3_);
  330.                   _loc14_ = true;
  331.                   break;
  332.                }
  333.                dispatchDragEvent(DragEvent.DRAG_ENTER,param1,_loc3_);
  334.                if(target == _loc3_)
  335.                {
  336.                   _loc14_ = false;
  337.                   break;
  338.                }
  339.                _loc3_ = _loc3_.parent;
  340.             }
  341.             if(!_loc14_)
  342.             {
  343.                dispatchDragEvent(DragEvent.DRAG_EXIT,param1,_loc15_);
  344.                if(target == _loc15_)
  345.                {
  346.                   target = null;
  347.                }
  348.             }
  349.          }
  350.          if(!target)
  351.          {
  352.             action = DragManager.MOVE;
  353.             _loc3_ = _loc12_;
  354.             while(_loc3_)
  355.             {
  356.                if(_loc3_ != this)
  357.                {
  358.                   dispatchDragEvent(DragEvent.DRAG_ENTER,param1,_loc3_);
  359.                   if(target)
  360.                   {
  361.                      break;
  362.                   }
  363.                }
  364.                _loc3_ = _loc3_.parent;
  365.             }
  366.             if(!target)
  367.             {
  368.                action = DragManager.NONE;
  369.             }
  370.          }
  371.          showFeedback();
  372.       }
  373.       
  374.       private function dispatchDragEvent(param1:String, param2:MouseEvent, param3:Object) : void
  375.       {
  376.          var _loc4_:DragEvent = new DragEvent(param1);
  377.          var _loc5_:Point = new Point();
  378.          _loc4_.dragInitiator = dragInitiator;
  379.          _loc4_.dragSource = dragSource;
  380.          _loc4_.action = action;
  381.          _loc4_.ctrlKey = param2.ctrlKey;
  382.          _loc4_.altKey = param2.altKey;
  383.          _loc4_.shiftKey = param2.shiftKey;
  384.          _loc5_.x = lastMouseEvent.localX;
  385.          _loc5_.y = lastMouseEvent.localY;
  386.          _loc5_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc5_);
  387.          _loc5_ = DisplayObject(param3).globalToLocal(_loc5_);
  388.          _loc4_.localX = _loc5_.x;
  389.          _loc4_.localY = _loc5_.y;
  390.          _dispatchDragEvent(DisplayObject(param3),_loc4_);
  391.       }
  392.       
  393.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  394.       {
  395.          checkKeyEvent(param1);
  396.       }
  397.       
  398.       private function effectEndHandler(param1:EffectEvent) : void
  399.       {
  400.          DragManager.endDrag();
  401.       }
  402.       
  403.       public function checkKeyEvent(param1:KeyboardEvent) : void
  404.       {
  405.          var _loc2_:DragEvent = null;
  406.          var _loc3_:Point = null;
  407.          if(target)
  408.          {
  409.             if(lastKeyEvent && param1.type == lastKeyEvent.type && param1.keyCode == lastKeyEvent.keyCode)
  410.             {
  411.                return;
  412.             }
  413.             lastKeyEvent = param1;
  414.             _loc2_ = new DragEvent(DragEvent.DRAG_OVER);
  415.             _loc2_.dragInitiator = dragInitiator;
  416.             _loc2_.dragSource = dragSource;
  417.             _loc2_.action = action;
  418.             _loc2_.ctrlKey = param1.ctrlKey;
  419.             _loc2_.altKey = param1.altKey;
  420.             _loc2_.shiftKey = param1.shiftKey;
  421.             _loc3_ = new Point();
  422.             _loc3_.x = lastMouseEvent.localX;
  423.             _loc3_.y = lastMouseEvent.localY;
  424.             _loc3_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc3_);
  425.             _loc3_ = DisplayObject(target).globalToLocal(_loc3_);
  426.             _loc2_.localX = _loc3_.x;
  427.             _loc2_.localY = _loc3_.y;
  428.             _dispatchDragEvent(target,_loc2_);
  429.             showFeedback();
  430.          }
  431.       }
  432.       
  433.       public function mouseLeaveHandler(param1:Event) : void
  434.       {
  435.          mouseUpHandler(lastMouseEvent);
  436.       }
  437.       
  438.       private function _dispatchDragEvent(param1:DisplayObject, param2:DragEvent) : void
  439.       {
  440.          var _loc3_:InterManagerRequest = null;
  441.          var _loc4_:InterDragManagerEvent = null;
  442.          if(isSameOrChildApplicationDomain(param1))
  443.          {
  444.             param1.dispatchEvent(param2);
  445.          }
  446.          else
  447.          {
  448.             _loc3_ = new InterManagerRequest(InterManagerRequest.INIT_MANAGER_REQUEST);
  449.             _loc3_.name = "mx.managers::IDragManager";
  450.             sandboxRoot.dispatchEvent(_loc3_);
  451.             _loc4_ = new InterDragManagerEvent(InterDragManagerEvent.DISPATCH_DRAG_EVENT,false,false,param2.localX,param2.localY,param2.relatedObject,param2.ctrlKey,param2.altKey,param2.shiftKey,param2.buttonDown,param2.delta,param1,param2.type,param2.dragInitiator,param2.dragSource,param2.action,param2.draggedItem);
  452.             sandboxRoot.dispatchEvent(_loc4_);
  453.          }
  454.       }
  455.       
  456.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  457.       {
  458.          checkKeyEvent(param1);
  459.       }
  460.       
  461.       public function stage_mouseMoveHandler(param1:MouseEvent) : void
  462.       {
  463.          if(param1.target != stage)
  464.          {
  465.             return;
  466.          }
  467.          mouseMoveHandler(param1);
  468.       }
  469.    }
  470. }
  471.